Tutorial https://www.kaggle.com/roshansharma/online-shopper-s-intention
DataSet https://archive.ics.uci.edu/ml/datasets/Online+Shoppers+Purchasing+Intention+Dataset
Quellen:
C. Okan Sakar:
Department of Computer Engineering, Faculty of Engineering and Natural Sciences, Bahcesehir University, 34349 Besiktas, Istanbul, Turkey
Yomi Kastro:
Inveon Information Technologies Consultancy and Trade, 34335 Istanbul, Turkey
1. Data
1.1 DataExploration/ExplainFeatures
1.1.1 DataSetInfo
1.1.2 DataSetDescribe
1.1.3 DataSetProfiling
1.1.3 DataSetPairPlot
1.2 Exploration (NULL)
1.3 Exploration (Classes)
1.4 Exploration and Preparation (Visualisation)
1.4.1 DataPreparation and Transformation
1.4.2 Exploration and HypothesenChecks (Visualisation)
2. Classification
2.1 Preparation
2.1.1 CleanDataFrame
2.1.2 Split des Datensatzes
2.2 Modellselection
2.3 Measure and Fit Standard Models
2.3.1 Multilayer ROC-Curve
3. Optimized-Classificaton
3.1 CrossValidation
3.2 KFold
3.3 RandomSearch+CrossValidation
3.3.1 BestScoredModel
3.3.2 ScoredModelList
3.3.3 Sorted ScoredModelList
3.3.4 Visualitation
3.4 ModelExplanation
3.4.1 Important Features
4. Clustering
4.1 Feature Selection
4.2 Train and Visualisation
9. TEST SECTION
import pandas as pd
import pandas_profiling
import numpy as np
import seaborn as sns
import time
import datetime
import matplotlib.pyplot as plt
plt.style.use('classic')
%matplotlib inline
%%time
df = pd.read_csv("data/eCommerce/online_shoppers_intention.csv")
df
"Administrative", "Administrative Duration", "Informational", "Informational Duration", "Product Related" und "Product Related Duration" stellen die Anzahl der verschiedenen Arten von Seiten dar, die der Besucher in dieser Sitzung besucht hat, sowie die Gesamtzeit, die in jeder dieser Seitenkategorien verbracht wurde. Die Werte dieser Funktionen werden aus den URL-Informationen der vom Benutzer besuchten Seiten abgeleitet und in Echtzeit aktualisiert, wenn ein Benutzer eine Aktion ausführt, z.B. von einer Seite zur anderen.
| Typ | URL (Beispiel) |
|---|---|
| Administrative | /?login |
| Administrative | /?logout |
| Administrative | /LoginRegister |
| Administrative | /passwordrecovery |
| .... | .... |
| Product Related | / |
| Product Related | /search |
| Product Related | /cart |
| .... | .... |
| Informational | /stores |
| Informational | /Catalog |
| .... | .... |
Die Funktionen "Bounce Rate", "Exit Rate" und "Page Value" stellen die von "Google Analytics" gemessenen Kennzahlen für jede Seite der E-Commerce-Site dar.
Der Wert der Funktion "Bounce Rate" für eine Webseite bezieht sich auf den Prozentsatz der Besucher, die die Webseite von dieser Seite aus betreten und dann verlassen ("Bounce"), ohne während dieser Sitzung weitere Anfragen an den Analyseserver zu richten.
Der Wert der Funktion "Exit Rate" für eine bestimmte Webseite wird wie bei allen Seitenaufrufen auf der Seite berechnet, der Prozentsatz, der der letzte in der Sitzung war.
Die Funktion "Page Value" stellt den Durchschnittswert für eine Webseite dar, die ein Benutzer vor Abschluss einer E-Commerce-Transaktion besucht hat.
Die Funktion "Special Day" zeigt die Nähe der Besuchszeit der Website zu einem bestimmten speziellen Tag (z.B. Muttertag, Valentinstag) an, an dem die Sitzungen eher mit der Transaktion abgeschlossen werden. Der Wert dieses Attributs wird unter Berücksichtigung der Dynamik des E-Commerce bestimmt, wie z.B. der Dauer zwischen Bestelldatum und Liefertermin. Zum Beispiel nimmt dieser Wert für den Valentinstag zwischen dem 2. und 12. Februar einen Wert ungleich Null an, Null vor und nach diesem Datum, es sei denn, er liegt nahe an einem anderen besonderen Tag, und seinen Höchstwert von 1 am 8. Februar. Der Datensatz enthält auch Betriebssystem, Browser, Region, Verkehrstyp, Besuchertyp als wiederkehrender oder neuer Besucher, einen booleschen Wert, der angibt, ob das Datum des Besuchs das Wochenende ist, und den Monat des Jahres.
"TrafficType" ist der Typ über den die Besucher auf die Website gekommen sind (z.B. Banner, SMS, direkt).
"Month","VisitorType" selbstsprechender kategorischer diskreter Wert.
"OperatingSystems", "Browser", "Region" kategorische, numerische Einteilung
"Revenue", "Weekend" boolsche Werte und sind selbstsprechend. Umsatz entstanden und am Wochenende True oder False
Die entsprechenden Features mit ihren Datentypen aufgezeigt.
df.info()
Erster einblick. Anzahl, Mittelwert, Standardabweichung, Quantile (0.25, 0.5, 0.75) sowie min und max
df.describe()
Das Profiling dient der generalisierten und standardisierten Betrachtung eines Datensatzes. Das Framework/Modul ermöglicht eine repräsentation die entsprechend gescrollt werden kann um einen ersten Einblick in den Datensatz zu erhalten.
!!Achtung einige Werte sind "kategorische" Werte bzw. verstecken sich hinter integer Werten auch kategorische Interpretationen!!
Diese Form dient der ersten Anschauung und bedarf einer tiefgreifenden Analyse im folgenden.
%%time
pandas_profiling.ProfileReport(df)
Der Pairplot ermöglicht eine Repräsentation der Verteilung auf und mit jedem Attribut. Das ist sofern von Nutzen da sich hier auch entsprechende Dopplungen bzw. Abhängigkeiten heraus kristalisieren. Diese bedarf es natürlich durch eine Korrelationsanalyse zu ermitteln und bei bedarf (was meistens der Fall ist) entfernen. Auffäligkeiten (auf den ersten Blick):
Sollten weiter untersucht werden
TypeObject kann nicht geplottet ... hier das entfernen aller Object Typen nötig
sns.set(style="ticks", color_codes=True)
testdf = df.drop(columns = ['VisitorType','Weekend','Revenue','Month'])
#testdf = df.drop(columns = ['VisitorType','Weekend','Revenue'])
#testdf = df.drop(columns = ['Weekend','Revenue','Month'])
#g = sns.pairplot(testdf)
#g = sns.pairplot(testdf)
#fig = g.get_figure()
#fig.savefig("pairplot.png")
%%time
g = sns.pairplot(testdf)
%%time
g.savefig("pairplot.png")
%%time
df.isnull().sum().sum()
%%time
df['Revenue'].value_counts()
import matplotlib.pyplot as plt
import plotly as py
import plotly.graph_objs as go
colorMaps
# Verteilung Umsatz J/N und am Wochende käufe J/N
plt.rcParams['figure.figsize'] = (12, 6)
plt.subplot(1, 2, 1)
sns.countplot(df['Revenue'], palette = 'winter')#CMRmap')#'bright')
plt.title('gekauft?', fontsize = 30)
plt.xlabel('Umsatz oder nicht', fontsize = 15)
plt.ylabel('Anzahl', fontsize = 15)
# checking the Distribution of customers on Weekend
plt.subplot(1, 2, 2)
sns.countplot(df['Weekend'], palette = 'deep')
plt.title('Wochenende?', fontsize = 30)
plt.xlabel('Wochenende oder nicht', fontsize = 15)
plt.ylabel('Anzahl', fontsize = 15)
plt.show()
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 1 | Der Umsatz hängt vom Wochenende ab | Der Umsatz hängt nicht vom Wochenende ab | H1 angenommen / Korrelationskoeffizient |
import numpy
print("Korrelationskoeffizient zwischen Weekend und Umsatz (Revenue): "+str(numpy.corrcoef(df['Weekend'], df['Revenue'])[0, 1]))
print("Gesamtlänge des DataFrames: "+str(len(df)))
print("################## Weekend ######################")
print(df['Weekend'].value_counts())
falsevalue_pct = round(9462/len(df),4)
print("Verhältnis False: "+str(falsevalue_pct))
truevalue_pct = round(1-falsevalue_pct,4)
print("Verhältnis True: "+str(truevalue_pct))
print("################## Revenue/Umsatz ######################")
print(df['Revenue'].value_counts())
falsevalue_pct = round(10422/len(df),4)
print("Verhältnis False: "+str(falsevalue_pct))
truevalue_pct = round(1-falsevalue_pct,4)
print("Verhältnis True: "+str(truevalue_pct))
# Kuchendiegramme
plt.rcParams['figure.figsize'] = (18, 7)
size = [10551, 1694, 85]
colors = ["#9b59b6", "#3498db", "#95a5a6"]
labels = "Returning Visitor", "New_Visitor", "Others"
explode = [0, 0.1, 0.1]
plt.subplot(1, 2, 1)
plt.pie(size, colors = colors, labels = labels, explode = explode, shadow = True, autopct = '%.2f%%')
plt.title('unterschiedliche Besucher', fontsize = 30)
plt.axis('off')
plt.legend()
# plotting a pie chart for browsers
size = [7961, 2462, 736, 467,174, 163, 300]
colors = ['orange', 'yellow', 'pink', 'crimson', 'lightgreen', 'cyan', 'blue']
labels = "2", "1","4","5","6","10","others"
explode = [0, 0.01,0.01,0.1,0.1,0.1, 0.1]
plt.subplot(1, 2, 2)
plt.pie(size, colors = colors, labels = labels, explode = explode,shadow = True, autopct = '%.2f%%', startangle = 90)
plt.title('unterschiedliche Browser', fontsize = 30)
plt.axis('off')
plt.legend()
plt.show()
df.replace({'VisitorType': 'New_Visitor'},value=1, inplace=True)
df.replace({'VisitorType': 'Other'},value=2, inplace=True)
df.replace({'VisitorType': 'Returning_Visitor'},value=3, inplace=True)
VSlist = df['VisitorType'].value_counts()
VSlist.sort_values(ascending=False, inplace=True, kind='quicksort')
VSlist
#print(df['OperatingSystems'].value_counts())
#print(df['Browser'].value_counts())
OSlist = df['OperatingSystems'].value_counts()
OSlist.sort_values(ascending=False, inplace=True, kind='quicksort')
OSlist
df.replace({'OperatingSystems': 5},value=4, inplace=True)
df.replace({'OperatingSystems': 7},value=4, inplace=True)
df.replace({'OperatingSystems': 6},value=4, inplace=True)
df.replace({'OperatingSystems': 8},value=4, inplace=True)
df.replace({'OperatingSystems': 4},value=3, inplace=True)
OSlist = df['OperatingSystems'].value_counts()
OSlist.sort_values(ascending=False, inplace=True, kind='quicksort')
OSlist
BWlist = df['Browser'].value_counts()
BWlist.sort_values(ascending=False, inplace=True, kind='quicksort')
BWlist
df.replace({'Browser': 9},value=6, inplace=True)
df.replace({'Browser': 11},value=6, inplace=True)
df.replace({'Browser': 12},value=6, inplace=True)
df.replace({'Browser': 7},value=6, inplace=True)
df.replace({'Browser': 13},value=6, inplace=True)
df.replace({'Browser': 3},value=6, inplace=True)
df.replace({'Browser': 8},value=6, inplace=True)
df.replace({'Browser': 10},value=6, inplace=True)
df.replace({'Browser': 4},value=3, inplace=True)
df.replace({'Browser': 5},value=4, inplace=True)
df.replace({'Browser': 6},value=5, inplace=True)
BWlist = df['Browser'].value_counts()
BWlist.sort_values(ascending=False, inplace=True, kind='quicksort')
BWlist
OSlist
# Kuchendiegramme
plt.rcParams['figure.figsize'] = (18, 7)
size = OSlist
colors = ["#9b59b6", "#3498db", "#95a5a6"]
labels = "Windows", "Linux & Other", "MacOS"
explode = [0, 0.1, 0.1]
plt.subplot(1, 2, 1)
plt.pie(size, colors = colors, labels = labels, explode = explode, shadow = True, autopct = '%.2f%%')
plt.title('unterschiedliche Betriebssysteme', fontsize = 30)
plt.axis('off')
plt.legend()
# plotting a pie chart for browsers
size = BWlist
colors = ['lightblue', '#3498db', 'orange', '#95a5a6', 'lightgreen']
labels = "Chrome", "Firefox","IE & Edge","Safari","Opera"
explode = [0, 0.1,0.1,0.1,0.1]
plt.subplot(1, 2, 2)
plt.pie(size, colors = colors, labels = labels, explode = explode,shadow = True, autopct = '%.2f%%', startangle = 90)
plt.title('unterschiedliche Browser', fontsize = 30)
plt.axis('off')
plt.legend()
plt.show()
# visualizing the distribution of customers around the Region
plt.rcParams['figure.figsize'] = (18, 7)
plt.subplot(1, 2, 1)
plt.hist(df['TrafficType'], color = 'lightgreen')
plt.title('Verteilung der unterschiedlichen Traffic Typen',fontsize = 20)
plt.xlabel('TrafficType Codes', fontsize = 15)
plt.ylabel('Anzahl', fontsize = 15)
# visualizing the distribution of customers around the Region
plt.subplot(1, 2, 2)
plt.hist(df['Region'], color = 'lightblue')
plt.title('Verteilung der Nutzer auf die Regionen',fontsize = 20)
plt.xlabel('Region Codes', fontsize = 15)
plt.ylabel('Anzahl', fontsize = 15)
plt.show()
# checking the no. of OSes each user is having
df['Region'].value_counts()
# checking the no. of OSes each user is having
df['OperatingSystems'].value_counts()
#checking the months with most no.of customers visiting the online shopping sites
df['Month'].value_counts()
# product related duration vs revenue
plt.rcParams['figure.figsize'] = (18, 15)
plt.subplot(2, 2, 1)
sns.boxenplot(df['Revenue'], df['Informational_Duration'], palette = 'rainbow')
plt.title('Info. duration vs Revenue', fontsize = 30)
plt.xlabel('Info. duration', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
# product related duration vs revenue
plt.subplot(2, 2, 2)
sns.boxenplot(df['Revenue'], df['Administrative_Duration'], palette = 'pastel')
plt.title('Admn. duration vs Revenue', fontsize = 30)
plt.xlabel('Admn. duration', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
# product related duration vs revenue
plt.subplot(2, 2, 3)
sns.boxenplot(df['Revenue'], df['ProductRelated_Duration'], palette = 'dark')
plt.title('Product Related duration vs Revenue', fontsize = 30)
plt.xlabel('Product Related duration', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
# exit rate vs revenue
plt.subplot(2, 2, 4)
sns.boxenplot(df['Revenue'], df['ExitRates'], palette = 'spring')
plt.title('ExitRates vs Revenue', fontsize = 30)
plt.xlabel('ExitRates', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
plt.show()
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 2 | Der Aufenthalt (Dauer) im Kontext der allgemeinen Informationssektionen hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der Aufenthalt (Dauer) im Kontext der allgemeinen Informationssektionen hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
| 3 | Der Aufenthalt (Dauer) im Kontext der Adminitrationssektion hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der Aufenthalt (Dauer) im Kontext der Adminitrationssektion hat eine Auswirkung auf bzw. Zusammenhang den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
| 4 | Der Aufenthalt (Dauer) im Kontext der Produktsektionen hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der Aufenthalt (Dauer) im Kontext der Produktsektionen hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
| 5 | Das Verlassen der Seite hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Das Verlassen der Seite hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
print("Korrelationskoeffizient zwischen ExitRates und Umsatz (Revenue): "+str(numpy.corrcoef(df['ExitRates'], df['Revenue'])[0, 1]))
print("Korrelationskoeffizient zwischen ProductRelated_Duration und Umsatz (Revenue): "+str(numpy.corrcoef(df['ProductRelated_Duration'], df['Revenue'])[0, 1]))
print("Korrelationskoeffizient zwischen Administrative_Duration und Umsatz (Revenue): "+str(numpy.corrcoef(df['Administrative_Duration'], df['Revenue'])[0, 1]))
print("Korrelationskoeffizient zwischen Informational_Duration und Umsatz (Revenue): "+str(numpy.corrcoef(df['Informational_Duration'], df['Revenue'])[0, 1]))
#page values vs revenue
plt.rcParams['figure.figsize'] = (18, 7)
plt.subplot(1, 2, 1)
sns.stripplot(df['Revenue'], df['PageValues'], palette = 'autumn')
plt.title('PageValues vs Revenue', fontsize = 30)
plt.xlabel('PageValues', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
# bounce rates vs revenue
plt.subplot(1, 2, 2)
sns.stripplot(df['Revenue'], df['BounceRates'], palette = 'magma')
plt.title('Bounce Rates vs Revenue', fontsize = 30)
plt.xlabel('Boune Rates', fontsize = 15)
plt.ylabel('Revenue', fontsize = 15)
plt.show()
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 6 | Der PageValue hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der PageValue hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann abgelehnt werden, Korrelationskoeffizient |
| 7 | Die BounceRate hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Die BounceRate hat eine Auswirkung auf bzw. Zusammenhang den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
print("Korrelationskoeffizient zwischen PageValue und Umsatz (Revenue): "+str(numpy.corrcoef(df['PageValues'], df['Revenue'])[0, 1]))
print("Korrelationskoeffizient zwischen BounceRate und Umsatz (Revenue): "+str(numpy.corrcoef(df['BounceRates'], df['Revenue'])[0, 1]))
# weekend vs Revenue
df_data = pd.crosstab(df['Weekend'], df['Revenue'])
df_data.div(df_data.sum(1).astype(float), axis = 0).plot(kind = 'bar', stacked = True, figsize = (7, 4), color = ['orange', 'crimson'])
plt.title('Weekend vs Revenue', fontsize = 20)
plt.show()
df_data
# Traffic Type vs Revenue
df_data = pd.crosstab(df['TrafficType'], df['Revenue'])
df_data.div(df_data.sum(1).astype(float), axis = 0).plot(kind = 'bar', stacked = True, figsize = (15, 5), color = ['lightpink', 'yellow'])
plt.title('Traffic Type vs Revenue', fontsize = 30)
plt.show()
df_data
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 8 | Der TrafficType hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der TrafficType hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
print("Korrelationskoeffizient zwischen TrafficType und Umsatz (Revenue): "+str(numpy.corrcoef(df['TrafficType'], df['Revenue'])[0, 1]))
import scipy
scipy.stats.spearmanr(df['TrafficType'],df['Revenue'])
# visitor type vs revenue
df_data = pd.crosstab(df['VisitorType'], df['Revenue'])
df_data.div(df_data.sum(1).astype(float), axis = 0).plot(kind = 'bar', stacked = True, figsize = (15, 5), color = ['lightgreen', 'green'])
plt.title('Visitor Type vs Revenue', fontsize = 30)
plt.show()
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 9 | Der PageValue hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Der PageValue hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
print("Korrelationskoeffizient zwischen PageValue und Umsatz (Revenue): "+str(numpy.corrcoef(df['VisitorType'], df['Revenue'])[0, 1]))
import scipy
scipy.stats.spearmanr(df['VisitorType'],df['Revenue'])
# region vs Revenue
df_data = pd.crosstab(df['Region'], df['Revenue'])
df_data.div(df_data.sum(1).astype(float), axis = 0).plot(kind = 'bar', stacked = True, figsize = (15, 5), color = ['blue', 'lightblue'])
plt.title('Region vs Revenue', fontsize = 30)
plt.show()
| Nr. | 0-Hypothese | A-Hypothese | Annahme / Verfahren |
|---|---|---|---|
| 10 | Die Region hat keine Auswirkung bzw. Zusammenhang auf den Umsatz | Die Region hat eine Auswirkung bzw. Zusammenhang auf den Umsatz | H0 kann nicht abgelehnt werden, Korrelationskoeffizient |
print("Korrelationskoeffizient zwischen Region und Umsatz (Revenue): "+str(numpy.corrcoef(df['Region'], df['Revenue'])[0, 1]))
import scipy
scipy.stats.spearmanr(df['Region'],df['Revenue'])
# lm plot
plt.rcParams['figure.figsize'] = (20, 10)
sns.lmplot(x = 'Administrative', y = 'Informational', data = df, x_jitter = 0.05)
plt.title('LM Plot between Admistrative and Information', fontsize = 15)
plt.show()
# Monat (X) vs pagevalues (Y) ausprägung Umsatz (revenue)
plt.rcParams['figure.figsize'] = (18, 15)
plt.subplot(2, 2, 1)
sns.boxplot(x = df['Month'], y = df['PageValues'], hue = df['Revenue'], palette = 'inferno')
plt.title('Monat (X) vs pagevalues (Y) Ausprägung Umsatz (revenue)', fontsize = 15)
# Monat (X) vs ExitRates (Y) Ausprägung Umsatz (revenue)
plt.subplot(2, 2, 2)
sns.boxplot(x = df['Month'], y = df['ExitRates'], hue = df['Revenue'], palette = 'Reds')
plt.title('Monat (X) vs ExitRates (Y) Ausprägung Umsatz (revenue)', fontsize = 15)
# Monat (X) vs BounceRate (Y) Ausprägung Umsatz (revenue)
plt.subplot(2, 2, 3)
sns.boxplot(x = df['Month'], y = df['BounceRates'], hue = df['Revenue'], palette = 'Oranges')
plt.title('Monat (X) vs BounceRate (Y) Ausprägung Umsatz (revenue)', fontsize = 15)
# VisitorType (X) vs BounceRate (Y) Ausprägung Umsatz (revenue)
plt.subplot(2, 2, 4)
sns.boxplot(x = df['VisitorType'], y = df['BounceRates'], hue = df['Revenue'], palette = 'Purples')
plt.title('VisitorType (X) vs BounceRate (Y) Ausprägung Umsatz (revenue)', fontsize = 15)
plt.show()
# visitor type vs exit rates w.r.t revenue
plt.rcParams['figure.figsize'] = (18, 15)
plt.subplot(2, 2, 1)
sns.violinplot(x = df['VisitorType'], y = df['ExitRates'], hue = df['Revenue'])#, palette = 'rainbow')
plt.title('Visitors vs ExitRates wrt Rev.', fontsize = 30)
# visitor type vs exit rates w.r.t revenue
plt.subplot(2, 2, 2)
sns.violinplot(x = df['VisitorType'], y = df['PageValues'], hue = df['Revenue'])#, palette = 'gnuplot')
plt.title('Visitors vs PageValues wrt Rev.', fontsize = 30)
# region vs pagevalues w.r.t. revenue
plt.subplot(2, 2, 3)
sns.violinplot(x = df['Region'], y = df['PageValues'], hue = df['Revenue'])#, palette = 'Greens')
plt.title('Region vs PageValues wrt Rev.', fontsize = 30)
#region vs exit rates w.r.t. revenue
plt.subplot(2, 2, 4)
sns.violinplot(x = df['Region'], y = df['ExitRates'], hue = df['Revenue'])#, palette = 'spring')
plt.title('Region vs Exit Rates w.r.t. Revenue', fontsize = 30)
plt.show()
Vorbereitung des Datensatzes für die verwendeten Modelle. Dazu sollten nurnoch numerische Werte im Datensatz vorhanden sein
Die gesamten Monate bzw. die Monate werden als eigenes Feature abgebildet
# one hot encoding für alle !!!
dfnew = pd.DataFrame(df)
df_data1 = pd.get_dummies(df)
df_data1.columns
# label encoding für den Umsatz
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
dfnew['Revenue'] = le.fit_transform(dfnew['Revenue'])
dfnew['Revenue'].value_counts()
# Abhängige und unabhängige Variablen
x = df_data1
# entfernen meines Targets (Umsatz)
x = x.drop(['Revenue'], axis = 1)
y = dfnew['Revenue']
# Dimensionen checken
print("Shape of x:", x.shape)
print("Shape of y:", y.shape)
# OneHotEncoding checken ... soweit okay
x.head(10)
Anpassung von x und y im vorgelaggerten Teil nötig
# Split des Datensatzes
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size = 0.3, random_state = 123)
# Dimensionen überprüfen
print("Shape of x_train :", x_train.shape)
print("Shape of y_train :", y_train.shape)
print("Shape of x_test :", x_test.shape)
print("Shape of y_test :", y_test.shape)
(https://scikit-learn.org/stable/modules/ensemble.html)
GradientBoostingClassifier
Die Vorteile von GBRT sind:
Die Nachteile von GBRT sind:
x Voting Classifier
# MODELLING
# Ensamble
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import BaggingClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.ensemble import AdaBoostClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import VotingClassifier
# Naiven
from sklearn.naive_bayes import GaussianNB
# linear
# https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression
from sklearn.linear_model import RidgeClassifier
from sklearn.linear_model import LogisticRegression
# GaussianProcess
# https://scikit-learn.org/stable/modules/generated/sklearn.gaussian_process.GaussianProcessClassifier.html
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.metrics import auc
from sklearn.metrics import roc_auc_score
from sklearn.metrics import roc_curve
from sklearn.metrics import precision_recall_fscore_support
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import cohen_kappa_score
from sklearn.metrics import accuracy_score
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import randint as sp_randint
model_RF = RandomForestClassifier()
model_RF.fit(x_train, y_train)
my_models = [
RandomForestClassifier(),
BaggingClassifier(),
ExtraTreesClassifier(),
AdaBoostClassifier(),
GradientBoostingClassifier(),
#VotingClassifier(estimators=1000),
GaussianNB(),
#RidgeClassifier(),
LogisticRegression()
]
my_models_name = [
'RandomForestClassifier (Ensamble)',
'BaggingClassifier (Ensamble)',
'ExtraTreesClassifier (Ensamble)',
'AdaBoostClassifier (Ensamble)',
'GradientBoostingClassifier (Ensamble)',
'GaussianNB (NaiveBayes)',
#'RidgeClassifier (linear)',
'LogisticRegression (linear)'
]
y_pred_array = []
for i in range(len(my_models)):
my_models[i].fit(x_train, y_train)
y_pred_array.append(my_models[i].predict(x_test))
#test = optimize_model_randomCV(my_models[1])
#test.predict(x_test)
param_dist = {"max_depth": [3, None],
"max_features": sp_randint(1, 11),
"min_samples_split": sp_randint(2, 11),
"bootstrap": [True, False],
"criterion": ["gini", "entropy"]}
my_opti_models = [
RandomizedSearchCV(estimator=RandomForestClassifier(), param_distributions=param_dist).fit(x_train, y_train),
BaggingClassifier(),
RandomizedSearchCV(estimator=ExtraTreesClassifier(), param_distributions=param_dist).fit(x_train, y_train),
AdaBoostClassifier(),
GradientBoostingClassifier(),
#VotingClassifier(estimators=1000),
GaussianNB(),
#RidgeClassifier(),
LogisticRegression()
]
precision_array = []
accuracy_array = []
accuracyBalanced_array = []
recall_array = []
TPR_array=[]
TNR_array = []
Fmeasure_array = []
for i in range(len(my_models)):
precision_array.append(precision_score(y_test, my_models[i].predict(x_test)))
accuracy_array.append(accuracy_score(y_test, my_models[i].predict(x_test)))
recall_array.append(recall_score(y_test, my_models[i].predict(x_test)))
TPR_array.append(recall_score(y_test, my_models[i].predict(x_test)))
TNR_array.append((1-(recall_score(y_test, my_models[i].predict(x_test)))))
Fmeasure_array.append(2*((precision_array[i]*recall_array[i])/(precision_array[i]+recall_array[i])))
accuracyBalanced_array.append( (TNR_array[i]+TPR_array[i])/2 )
d = {'Model': my_models_name,
'Precision': precision_array,
'Accuracy': accuracy_array,
'Balanced Accuracy': accuracyBalanced_array,
'Recall': recall_array,
'TPR': TPR_array,
'TNR': TNR_array,
'Fmeasure': Fmeasure_array}
dataframe_with_scores = pd.DataFrame(data=d)
dataframe_with_scores
rf_roc_auc_array = []
fpr_array = []
tpr_array = []
thresholds_array = []
plt.figure(figsize=(12,6))
for i in range(len(my_models)):
rf_roc_auc_array.append(roc_auc_score(y_test, my_models[i].predict(x_test)))
fpr, tpr, thresholds = roc_curve(y_test, my_models[i].predict_proba(x_test)[:,1])
fpr_array.append(fpr)
tpr_array.append(tpr)
thresholds_array.append(thresholds)
plt.plot(fpr, tpr, label=my_models_name[i]+' (area = %0.2f)' % rf_roc_auc_array[i])
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate / Falsch erkannte Treffer')
plt.ylabel('True Positive Rate / Richtig erkannte Treffer')
plt.title('Receiver operating characteristic - ROC-Graph')
plt.legend(loc="lower right")
plt.savefig('RF_ROC')
plt.show()
https://scikit-learn.org/stable/modules/cross_validation.html
dfnew = pd.DataFrame(df)
df_data1 = pd.get_dummies(df)
df_data1.columns
le = LabelEncoder()
dfnew['Revenue'] = le.fit_transform(dfnew['Revenue'])
dfnew['Revenue'].value_counts()
# Abhängige und unabhängige Variablen
x = df_data1
# entfernen meines Targets (Umsatz)
x = x.drop(['Revenue'], axis = 1)
y = dfnew['Revenue']
# Dimensionen checken
print("Shape of x:", x.shape)
print("Shape of y:", y.shape)
from sklearn import datasets, linear_model
from sklearn.model_selection import cross_val_score
#xtrain, xtest, ytrain, ytest = train_test_split(x, y, test_size = 0.3, random_state = 123)
X = x
y = y
for i in range(len(my_models)):
print("CV: "+str(cross_val_score(my_models[i], X, y, cv=6))+" <- "+str(my_models_name[i]))
from sklearn.model_selection import cross_validate
from sklearn.metrics.scorer import make_scorer
from sklearn.metrics import confusion_matrix
from sklearn.metrics import recall_score
#scoring = ['precision_macro', 'recall_macro']
scoring = {'prec_macro': 'precision_macro','rec_macro': make_scorer(recall_score, average='macro')}
for i in range(len(my_models)):
cv_results = cross_validate(my_models[i], X, y, cv=10, scoring=scoring)
#print(i)
cv_results.update( {'Modell' : my_models_name[i]} )
cv_results
if i == 0:
dfdict = pd.DataFrame.from_dict(cv_results, orient='columns')
else:
dftemp = pd.DataFrame.from_dict(cv_results, orient='columns')
dfdict = dfdict.append(dftemp)
dfdict.head(7)
dfdict.sort_values(by=['fit_time'], ascending=True).head(10)
dfdict.sort_values(by=['test_prec_macro','fit_time'], ascending=False).head(10)
dfnew = pd.DataFrame(df)
df_data1 = pd.get_dummies(df)
df_data1.columns
le = LabelEncoder()
dfnew['Revenue'] = le.fit_transform(dfnew['Revenue'])
dfnew['Revenue'].value_counts()
# Abhängige und unabhängige Variablen
x = df_data1
# entfernen meines Targets (Umsatz)
x = x.drop(['Revenue'], axis = 1)
y = dfnew['Revenue']
# Dimensionen checken
print("Shape of x:", x.shape)
print("Shape of y:", y.shape)
import numpy as np
from sklearn.model_selection import KFold
def best_kfold_fitted_model(model_list,models_name_list,x,y,n_splits):
xnew = x
ynew = y
#KFOLD Config
kf = KFold(n_splits=n_splits)
kf.get_n_splits(xnew)
#die ganzen score arrays ... koennen ausgeduent werden !!!!
precision_array = []
accuracy_array = []
accuracyBalanced_array = []
recall_array = []
TPR_array=[]
TNR_array = []
Fmeasure_array = []
name_array = []
fold_array = []
j=0
#return Values für die rueckgabe
bestACC = 0.0
bestF1 = 0.0
bestPre = 0.0
bestmodel = 0
for train_index, test_index in kf.split(xnew):
print("TRAIN:", train_index, "TEST:", test_index)
kfold_x_train, kfold_x_test = xnew.iloc[train_index], xnew.iloc[test_index]
kfold_y_train, kfold_y_test = ynew.iloc[train_index], ynew.iloc[test_index]
for i in range(len(model_list)):
model_list[i].fit(kfold_x_train, kfold_y_train)
precision_array.append(precision_score(kfold_y_test, model_list[i].predict(kfold_x_test)))
accuracy_array.append(accuracy_score(kfold_y_test, model_list[i].predict(kfold_x_test)))
recall_array.append(recall_score(kfold_y_test, model_list[i].predict(kfold_x_test)))
TPR_array.append(recall_score(kfold_y_test, model_list[i].predict(kfold_x_test)))
TNR_array.append((1-(recall_score(kfold_y_test, model_list[i].predict(kfold_x_test)))))
Fmeasure_array.append(2*((precision_array[i]*recall_array[i])/(precision_array[i]+recall_array[i])))
accuracyBalanced_array.append( (TNR_array[i]+TPR_array[i])/2 )
name_array.append(models_name_list[i])
fold_array.append(j)
tempACC = accuracy_score(kfold_y_test, model_list[i].predict(kfold_x_test))
tempPre = precision_score(kfold_y_test, model_list[i].predict(kfold_x_test))
tempF1 = 2*((precision_array[i]*recall_array[i])/(precision_array[i]+recall_array[i]))
print(tempACC)
if bestACC < tempACC and bestF1 < tempF1 and bestPre < tempPre:
#if bestACC < tempACC:
print('erreicht')
bestACC = tempACC
bestF1 = tempF1
bestPre = tempPre
bestIndex = i
bestmodel = model_list[i]
j+=1
d = {'Model': name_array,
'Fold Number': fold_array,
'Precision': precision_array,
'Accuracy': accuracy_array,
'Balanced Accuracy': accuracyBalanced_array,
'Recall': recall_array,
'TPR': TPR_array,
'TNR': TNR_array,
'Fmeasure': Fmeasure_array}
return pd.DataFrame(data=d), [bestIndex,bestmodel,bestACC,bestPre,bestF1]
dataframe_with_scores, bestmodel = best_kfold_fitted_model(my_models,my_models_name,x,y,8)
my_models = [
RandomForestClassifier(),
BaggingClassifier(),
ExtraTreesClassifier(),
AdaBoostClassifier(),
GradientBoostingClassifier(),
#VotingClassifier(estimators=1000),
GaussianNB(),
#RidgeClassifier(),
LogisticRegression()
]
my_models_name = [
'RandomForestClassifier (Ensamble)',
'BaggingClassifier (Ensamble)',
'ExtraTreesClassifier (Ensamble)',
'AdaBoostClassifier (Ensamble)',
'GradientBoostingClassifier (Ensamble)',
'GaussianNB (NaiveBayes)',
#'RidgeClassifier (linear)',
'LogisticRegression (linear)'
]
cpu_cores = 8
param_dist = [{"max_depth": [1,3,5,7,9,11, None],
"max_features": sp_randint(1, 11),
"min_samples_split": sp_randint(2, 11),
"bootstrap": [True, False],
"criterion": ["gini", "entropy"],
"class_weight": [None],
"max_leaf_nodes": [None],
"min_impurity_decrease": [0.0, 0.1, 0.2],
"min_impurity_split": [None],
"min_samples_leaf": sp_randint(1, 11),
"n_estimators": [50,100,200,500],
"n_jobs": [cpu_cores],
"min_weight_fraction_leaf": [0.0, 0.1, 0.2],
"random_state": [None, 42, 132],
"warm_start": [True, False]
},
{"bootstrap": [True, False],
"bootstrap_features": [True, False],
"max_features": [1.0],
"max_samples": [1.0],
"n_estimators": [10,50,100,200,500],
"n_jobs": [cpu_cores],
"random_state": [None, 42, 132],
"warm_start": [True, False]
},
{"max_depth": [1,3,5,7,9,11, None],
"max_features": sp_randint(1, 11),
"min_samples_split": sp_randint(2, 11),
"bootstrap": [True, False],
"criterion": ["gini", "entropy"],
"class_weight": [None],
"max_leaf_nodes": [None],
"min_impurity_decrease": [0.0, 0.1, 0.2],
"min_impurity_split": [None],
"min_samples_leaf": sp_randint(1, 11),
"min_samples_split": sp_randint(2, 11),
"n_estimators": [50,100,200,500],
"n_jobs": [cpu_cores],
"min_weight_fraction_leaf": [0.0, 0.1, 0.2],
"random_state": [None, 42, 132],
"warm_start": [True, False]
},
{"algorithm": ['SAMME.R', 'SAMME'],
"learning_rate": [1.0],
"n_estimators": [10,50,100,200,500],
"random_state": [None, 42, 132],
},
{"criterion": ['friedman_mse', 'mse', 'mae'], #mean absolute error (mae).
"learning_rate": [0.1],
"loss": ['deviance', 'exponential'],
"max_depth": sp_randint(2, 11),
"min_samples_leaf": sp_randint(1, 11),
"min_samples_split": sp_randint(2, 11),
"n_estimators": [10,20,30],
"min_weight_fraction_leaf": [0.0, 0.1, 0.2],
"random_state": [None, 42, 132],
"warm_start": [True, False],
"presort": ['auto'],
"subsample": [1.0],
"tol": [0.0001],
"validation_fraction": [0.1]
},
{"var_smoothing": [1e-09]
},
{"C": [1.0, 0.5, 1.1, 0.9],
"fit_intercept": [True, False],
"intercept_scaling": sp_randint(1, 11),
"l1_ratio": [None],
"max_iter": [100,200,500,1000],
"multi_class": ['ovr','multinomial','auto'],
"n_jobs": [cpu_cores],
"penalty": ['l2'],
"tol": [0.0001],
"random_state": [None, 42, 132],
"warm_start": [True, False],
"solver": ['lbfgs', 'sag', 'saga'],
}]
#param_dist[0]['max_depth']
#param_dist
#for i in range(len(my_models)):
# print(my_models[i])
print(__doc__)
import numpy as np
from time import time
from scipy.stats import randint as sp_randint
from sklearn.model_selection import RandomizedSearchCV
import numpy as np
from sklearn.model_selection import KFold
# SupportMethode die die Scores ausgibt und die besten Paramter zurueck gibt
def get_best_params_and_report(results, n_top=3):
for i in range(1, n_top + 1):
candidates = np.flatnonzero(results['rank_test_score'] == i)
for candidate in candidates:
print("Model with rank: {0} Mean validation score: {1:.3f} (std: {2:.3f})".format(i,
results['mean_test_score'][candidate],
results['std_test_score'][candidate]))
#print("Parameters: {0}".format(results['params'][candidate]))
#print("")
if i == 1:
bestparams = results['params'][candidate]
bestscore = {'mean':results['mean_test_score'][candidate],'std': results['std_test_score'][candidate]}
return bestparams, bestscore
#Stellt das beste Modell bereit
def best_opti_fitted_model(model_list,models_name_list,param_dict_list,x,y,xtest,ytest):
xnew = x
ynew = y
xtest = xtest
ytest = ytest
#die ganzen score arrays ... koennen ausgeduent werden !!!!
precision_array = []
accuracy_array = []
accuracyBalanced_array = []
recall_array = []
TPR_array=[]
TNR_array = []
Fmeasure_array = []
name_array = []
time_to_optimized_hyperParameters = []
#return Values für die rueckgabe
bestACC = 0.0
bestF1 = 0.0
bestPre = 0.0
bestRec = 0.0
bestmodel = 0
bestscoreList = []
bestscoreList2 = []
#RandomizedHyperparamter
n_iter_search = 20
for i in range(len(model_list)):
#RandomInitializedModel
random_search = RandomizedSearchCV(my_models[i], param_distributions=param_dict_list[i],n_iter=n_iter_search, cv=5, iid=False)
start = time()
random_search.fit(xnew, ynew)
time_to_optimized_hyperParameters.append(time() - start)
print("\n######### "+str(models_name_list[i])+" #########")
print("RandomizedSearchCV took %.2f seconds for %d candidates parameter settings." % (time_to_optimized_hyperParameters[i], n_iter_search))
bestparams, bestscore = get_best_params_and_report(random_search.cv_results_)
bestscoreList.append(bestscore['mean'])
bestscoreList2.append(bestscore['std'])
model_list[i] = random_search.best_estimator_
model_list[i].fit(xnew, ynew)
#Berechnung der Scores
precision_array.append(precision_score(ytest, model_list[i].predict(xtest)))
accuracy_array.append(accuracy_score(ytest, model_list[i].predict(xtest)))
recall_array.append(recall_score(ytest, model_list[i].predict(xtest)))
TPR_array.append(recall_score(ytest, model_list[i].predict(xtest)))
TNR_array.append((1-(recall_score(ytest, model_list[i].predict(xtest)))))
Fmeasure_array.append(2*((precision_array[i]*recall_array[i])/(precision_array[i]+recall_array[i])))
accuracyBalanced_array.append( (TNR_array[i]+TPR_array[i])/2 )
name_array.append(models_name_list[i])
#Selektion Section
tempACC = accuracy_score(ytest, model_list[i].predict(xtest))
tempPre = precision_score(ytest, model_list[i].predict(xtest))
tempF1 = 2*((precision_array[i]*recall_array[i])/(precision_array[i]+recall_array[i]))
tempRec = recall_score(ytest, model_list[i].predict(xtest))
print(tempACC)
if bestF1 < tempF1 and bestPre < tempPre and bestRec < tempRec:
#if bestACC < tempACC:
print('######## Treffer -> Save -> '+str(name_array[i])+' ########')
bestACC = tempACC
bestF1 = tempF1
bestPre = tempPre
bestRec = tempRec
bestIndex = i
bestmodel = model_list[i]
d = {'Model': name_array,
'Precision': precision_array,
'Accuracy': accuracy_array,
'Balanced Accuracy': accuracyBalanced_array,
'Recall': recall_array,
'TPR': TPR_array,
'TNR': TNR_array,
'Fmeasure': Fmeasure_array,
'Opti_MeanValidationScore': bestscoreList,
'Opti_StdScore': bestscoreList2,
'Opti_TimeToHyP': time_to_optimized_hyperParameters}
return pd.DataFrame(data=d), [bestIndex,bestmodel,bestACC,bestPre,bestF1]
dfnew = pd.DataFrame(df)
df_data1 = pd.get_dummies(df)
df_data1.columns
le = LabelEncoder()
dfnew['Revenue'] = le.fit_transform(dfnew['Revenue'])
dfnew['Revenue'].value_counts()
# Abhängige und unabhängige Variablen
x = df_data1
# entfernen meines Targets (Umsatz)
x = x.drop(['Revenue'], axis = 1)
y = dfnew['Revenue']
# Dimensionen checken
print("Shape of x:", x.shape)
print("Shape of y:", y.shape)
xnew_train, xnew_test, ynew_train, ynew_test = train_test_split(x, y, test_size = 0.2, random_state = 123)
print(xnew_train.shape)
print(xnew_test.shape)
print(ynew_train.shape)
print(ynew_test.shape)
#Mehtode wird ausgeführt ... kann dauern
dataframe_with_scores, bestmodel = best_opti_fitted_model(my_models,my_models_name,param_dist,xnew_train,ynew_train,xnew_test,ynew_test)
bestmodel
dataframe_with_scores.head(10)
dataframe_with_scores.sort_values(by=['Precision','Fmeasure','Accuracy'], ascending=False).head(10)
dataframe_with_scores.sort_values(by=['Precision','Fmeasure','Accuracy'], ascending=False).iloc[0:4]
dataframe_with_scores.sort_values(by=['Fmeasure'], ascending=False).iloc[0:10]
plt.figure(figsize=(12,6))
for i in range(len(my_models)):
rf_roc_auc_array.append(roc_auc_score(ynew_test, my_models[i].predict(xnew_test)))
fpr, tpr, thresholds = roc_curve(ynew_test, my_models[i].predict_proba(xnew_test)[:,1])
fpr_array.append(fpr)
tpr_array.append(tpr)
thresholds_array.append(thresholds)
plt.plot(fpr, tpr, label=my_models_name[i]+' (area = %0.2f)' % rf_roc_auc_array[i])
plt.plot([0, 1], [0, 1],'r--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate / Falsch erkannte Treffer')
plt.ylabel('True Positive Rate / Richtig erkannte Treffer')
plt.title('Receiver operating characteristic - ROC-Graph -> Optimierte Modelle')
plt.legend(loc="lower right")
plt.savefig('RF_ROC_opti3')
plt.show()
| Standard ModelConfig | Optimized ModelConfig |
|---|---|
![]() |
![]() |
SHAP (SHapley Additive exPlanations) is a unified approach to explain the output of any machine learning model. SHAP connects game theory with local explanations, uniting several previous methods [1-7] and representing the only possible consistent and locally accurate additive feature attribution method based on expectations (see our papers for details and citations).
SHAP (SHapley Additive exPlanations) ist ein einheitlicher Ansatz, um die Ergebnisse eines jeden maschinellen Lernmodells zu erklären. SHAP verbindet Spieltheorie mit lokalen Erklärungen, vereint mehrere frühere Methoden[1-7] und stellt die einzig mögliche konsistente und lokal genaue Methode zur Attributierung von additiven Merkmalen basierend auf Erwartungen dar (siehe unsere Papiere für Details und Zitate).
Quelle: https://github.com/slundberg/shap
Abbildung der einzelnen Monate durch den LabelEncounter möglich bzw. OneHotEncoding
#RandomForest
# let's take a look at the shap values
# importing shap
import shap
explainer = shap.TreeExplainer(my_models[0])
shap_values = explainer.shap_values(x_test)
shap.summary_plot(shap_values[1], x_test, plot_type = 'bar')
shap.summary_plot(shap_values[1], x_test)
shap_values = explainer.shap_values(x_train.iloc[:50])
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values[1], x_test.iloc[:50])
#shap.TreeExplainer(my_models[0]).shap_interaction_values(x_test)
#ExtraTree
explainer = shap.TreeExplainer(my_models[2])
shap_values = explainer.shap_values(x_test)
shap.summary_plot(shap_values[1], x_test, plot_type = 'bar')
shap.summary_plot(shap_values[1], x_test)
shap_values = explainer.shap_values(x_train.iloc[:50])
shap.initjs()
shap.force_plot(explainer.expected_value[1], shap_values[1], x_test.iloc[:50])
#shap.TreeExplainer(my_models[2]).shap_interaction_values(x_test)
df_data1.head(2)
# Q1: Time Spent by The Users on Website vs Bounce Rates
'''
Bounce Rate :The percentage of visitors to a particular website who navigate away from the site after
viewing only one page.
'''
# Vorbereitung zum Clustern der Adminitrativen Duration und der BounceRate
x = df.iloc[:, [1, 6]].values
# checking the shape of the dataset
x.shape
from sklearn.cluster import KMeans
#Maximale Distant zwischen den Clustern
wcss = []
for i in range(1, 11):
km = KMeans(n_clusters = i,
init = 'k-means++',
max_iter = 600,
n_init = 10,
random_state = 0,
algorithm = 'elkan',
tol = 0.001)
km.fit(x)
labels = km.labels_
wcss.append(km.inertia_)
plt.rcParams['figure.figsize'] = (15, 7)
plt.plot(range(1, 11), wcss)
plt.grid()
plt.tight_layout()
plt.title('The Elbow Method', fontsize = 20)
plt.xlabel('No. of Clusters')
plt.ylabel('wcss')
plt.show()
km = KMeans(n_clusters = 3, init = 'k-means++', max_iter = 1000, n_init = 10, random_state = 0)
y_means = km.fit_predict(x)
plt.scatter(x[y_means == 0, 0], x[y_means == 0, 1], s = 100, c = 'green', label = 'Un-interested Customers')
plt.scatter(x[y_means == 1, 0], x[y_means == 1, 1], s = 100, c = 'yellow', label = 'General Customers')
plt.scatter(x[y_means == 2, 0], x[y_means == 2, 1], s = 100, c = 'red', label = 'Target Customers')
plt.scatter(km.cluster_centers_[:,0], km.cluster_centers_[:, 1], s = 50, c = 'blue' , label = 'centeroid')
plt.title('Administrative Duration vs Duration Bounce Rate', fontsize = 20)
plt.grid()
plt.xlabel('Administrative Duration')
plt.ylabel('Bounce Rates')
plt.legend()
plt.show()

from sklearn.model_selection import GridSearchCV
model = RandomForestClassifier()
grid = GridSearchCV(estimator=model,
param_grid={
'max_depth': [3, None],
'n_estimators': (10, 30, 50, 100, 200),# 400, 600, 800, 1000),
'max_features': (2,4,6)
},
cv=10, n_jobs=-1,)
grid.fit(x_train, y_train)
print(grid)
# summarize the results of the grid search
print(grid.best_score_)
#print(grid.best_estimator_.alpha)
dfnew = pd.DataFrame(df)
df_data1 = pd.get_dummies(df)
df_data1.columns
le = LabelEncoder()
dfnew['Revenue'] = le.fit_transform(dfnew['Revenue'])
dfnew['Revenue'].value_counts()
# Abhängige und unabhängige Variablen
x = df_data1
# entfernen meines Targets (Umsatz)
x = x.drop(['Revenue'], axis = 1)
y = dfnew['Revenue']
# Dimensionen checken
print("Shape of x:", x.shape)
print("Shape of y:", y.shape)
# SupportMethode die die Scores ausgibt und die besten Paramter zurueck gibt
def get_best_params_and_report(results, n_top=3):
for i in range(1, n_top + 1):
candidates = np.flatnonzero(results['rank_test_score'] == i)
for candidate in candidates:
print("Model with rank: {0}".format(i))
print("Mean validation score: {0:.3f} (std: {1:.3f})".format(
results['mean_test_score'][candidate],
results['std_test_score'][candidate]))
print("Parameters: {0}".format(results['params'][candidate]))
print("")
if i == 1:
bestparams = results['params'][candidate]
bestscore = {'mean':results['mean_test_score'][candidate],'std': results['std_test_score'][candidate]}
return bestparams, bestscore
#Stellt das beste Modell bereit
n_iter_search = 20
random_search = RandomizedSearchCV(my_models[0], param_distributions=param_dist[0],n_iter=n_iter_search, cv=5, iid=False)
random_search.fit(x, y)
start = time()
print("RandomizedSearchCV took %.2f seconds for %d candidates parameter settings." % ((time() - start), n_iter_search))
bestparams, bestscore = get_best_params_and_report(random_search.cv_results_)
print(bestparams['bootstrap'])
bestparams
random_search.best_estimator_
bestscore
from sklearn.cluster import SpectralClustering
from sklearn.cluster import dbscan